#ifndef THREADSAFEQUEUE_H
#define THREADSAFEQUEUE_H

#include <queue>
#include <mutex>
#include <condition_variable>

/**
 * @brief 线程安全队列模板类
 * @tparam T 队列元素类型
 */
template<typename T>
class ThreadSafeQueue {
public:
    /**
     * @brief 构造函数
     * @param max_size 队列最大容量，默认为1000
     */
    ThreadSafeQueue(size_t max_size = 100) : max_size_(max_size) {}
    ~ThreadSafeQueue() = default;

    /**
     * @brief 设置队列最大容量
     * @param max_size 新的最大容量
     */
    void setMaxSize(size_t max_size) {
        std::unique_lock<std::mutex> lock(mutex_);
        max_size_ = max_size;
        // 如果当前队列超过新的大小限制，移除最早的元素
        while (queue_.size() > max_size_) {
            queue_.pop();
        }
    }

    /**
     * @brief 向队列添加元素
     * @param value 要添加的元素
     */
    void push(const T& value) {
        std::unique_lock<std::mutex> lock(mutex_);
        // 如果队列已满，移除最早的元素
        if (queue_.size() >= max_size_) {
            queue_.pop();
        }
        queue_.push(value);
        //lock.unlock();
        cond_.notify_one();
    }

    /**
     * @brief 从队列获取元素
     * @return 队列中的第一个元素
     */
    T pop() {
        std::unique_lock<std::mutex> lock(mutex_);
        cond_.wait(lock, [this]{ return !queue_.empty(); });
        T value = queue_.front();
        queue_.pop();
        return value;
    }

    /**
     * @brief 尝试从队列获取元素
     * @param value 获取到的元素
     * @return 成功获取返回true，队列为空返回false
     */
    bool try_pop(T& value) {
        std::unique_lock<std::mutex> lock(mutex_);
        if (queue_.empty()) {
            return false;
        }
        value = queue_.front();
        queue_.pop();
        return true;
    }

    /**
     * @brief 检查队列是否为空
     * @return 队列为空返回true，否则返回false
     */
    bool empty() const {
        std::unique_lock<std::mutex> lock(mutex_);
        return queue_.empty();
    }

    /**
     * @brief 清空队列
     */
    void clear() {
        std::unique_lock<std::mutex> lock(mutex_);
        while (!queue_.empty()) {
            queue_.pop();
        }
    }

    /**
     * @brief 获取队列大小
     * @return 队列中元素的数量
     */
    size_t size() const {
        std::unique_lock<std::mutex> lock(mutex_);
        return queue_.size();
    }

private:
    mutable std::mutex mutex_;
    std::condition_variable cond_;
    std::queue<T> queue_;
    size_t max_size_;  ///< 队列最大容量
};

#endif // THREADSAFEQUEUE_H
